In `@CLAUDE.md`:
- Around line 76-83: Add a blank line immediately before the fenced code block
that starts with "```yaml" in CLAUDE.md so the code block is separated from the
preceding paragraph (to satisfy markdownlint MD031); locate the block containing
"llm:" and ensure there is an empty line above the opening ```yaml fence so the
fenced code block is properly surrounded by blank lines.

In `@src/hooks/utils/config.ts`:
- Around line 128-132: Export VALID_PROVIDERS (and optionally isValidProvider)
so other modules can reuse the canonical list and validator; update the
declaration of VALID_PROVIDERS to be exported (export const VALID_PROVIDERS) and
export the isValidProvider function (export function isValidProvider) or move
both to the domain layer alongside the LLMProvider type if preferred, ensuring
imports elsewhere (e.g., LLMClientFactory, CLI validation) reference the
exported symbols VALID_PROVIDERS and isValidProvider.

In `@src/infrastructure/di/container.ts`:
- Around line 116-127: The DI registration for intentExtractor is using an
unsafe double-cast for caller (client as unknown as ILLMCaller); change the
types so no cast is required: update the llm client type exposed on the
container (container.cradle.llmClient) to satisfy ILLMCaller (either by having
the concrete ILLMClient implement/extend ILLMCaller or by typing llmClient as
ILLMCaller), then instantiate new IntentExtractor({ caller:
container.cradle.llmClient, logger: container.cradle.logger }) without casting;
ensure interface names referenced are ILLMCaller, any existing ILLMClient
implementation, and the IntentExtractor constructor signature remain consistent.

In `@src/infrastructure/llm/BaseLLMClient.ts`:
- Around line 4-9: Update the class header comment in BaseLLMClient to remove
the reference to the non-existent callComplete() and state that concrete
providers only need to implement callAPI(); reference the class name
BaseLLMClient and the method callAPI() so the documentation matches the actual
abstract API surface.
- Around line 70-105: The complete method in BaseLLMClient ignores
options.maxTokens so callers can't limit output; update the call flow to accept
and propagate maxTokens: change the abstract callAPI signature to include an
optional maxTokens parameter (e.g., callAPI(systemPrompt: string, userMessage:
string, maxTokens?: number): Promise<IAPICallResult>), update
BaseLLMClient.complete to pass options.maxTokens into callAPI, and update all
provider implementations (Anthropic/OpenAI/Gemini/Ollama) to accept and honor
the optional maxTokens when making their API requests; ensure any type/interface
definitions (ILLMCallerOptions, provider call signatures) are updated
accordingly.

In `@src/infrastructure/llm/GeminiLLMClient.ts`:
- Around line 41-49: The code is triggering ESLint rules for an explicit any and
using require(); update the optional dependency loading in GeminiLLMClient by
adding the same inline ESLint directives used in OpenAILLMClient: annotate the
GoogleGenerativeAI variable to avoid the no-explicit-any rule and wrap the
require call with a no-require-imports eslint-disable-next-line comment (and
re-enable if needed), then keep the existing try/catch that throws LLMError if
the module is absent; reference the GoogleGenerativeAI variable and the
require('@google/generative-ai') usage to locate where to add these directives.

In `@src/infrastructure/llm/LLMClientFactory.ts`:
- Around line 38-83: ESLint flags the synchronous require() calls inside
LLMClientFactory (the switch cases for 'anthropic', 'openai', 'gemini',
'ollama') as forbidden; either convert the factory to an async function and
replace each require('./XLLMClient') with await import('./XLLMClient') and then
construct the client (e.g., import { OpenAILLMClient } via await import and
return new OpenAILLMClient(...)), or keep the synchronous API and add targeted
eslint-disable-next-line comments immediately above each require with a brief
justification that these are optional peer-dependency lazy-loads; update callers
if you choose the async approach so they await LLMClientFactory.create(...) (or
equivalent factory function).

In `@src/infrastructure/llm/OpenAILLMClient.ts`:
- Around line 44-52: The code in OpenAILLMClient.ts uses a require() and an
any-typed variable which trigger ESLint rules; update the optional dependency
loading block that sets OpenAI (and uses mod) to include inline ESLint disables
for `@typescript-eslint/no-explicit-any` and
`@typescript-eslint/no-require-imports`, and move the orphaned comment from lines
~13-14 into this usage site above the try/catch; ensure the thrown LLMError
remains unchanged and reference the OpenAI variable and mod/default resolution
(mod.default ?? mod) so the linter exceptions only apply to this optional-import
pattern.

In `@tests/unit/infrastructure/llm/OpenAILLMClient.test.ts`:
- Around line 8-26: The finally block in the OpenAILLMClient.test.ts case
doesn't correctly restore the environment: change the cleanup so that after the
test the OPENAI_API_KEY is restored to its original value when saved !==
undefined, and explicitly deleted (delete process.env.OPENAI_API_KEY) when saved
is undefined; update the finally block around the new OpenAILLMClient()
assertion to mirror the Gemini test pattern and use the saved variable to decide
between restoring the value or removing the env var.

In `@src/infrastructure/llm/AnthropicLLMClient.ts`:
- Around line 38-60: The AnthropicLLMClient.callAPI implementation lacks
consistent SDK error wrapping; update the callAPI method in the
AnthropicLLMClient class to wrap the SDK call in a try/catch, catch any thrown
error from this.client.messages.create or subsequent processing, and rethrow a
new LLMError (including context like model, systemPrompt/userMessage summary,
and the original error) so that direct calls to complete() receive the same
LLMError shape as OpenAILLMClient and GeminiLLMClient.

In `@src/infrastructure/llm/LLMClientFactory.ts`:
- Around line 35-44: The Anthropic branch in LLMClientFactory uses a dynamic
require for AnthropicLLMClient but lacks the try/catch wrapper other providers
use; wrap the require and instantiation in a try/catch around the block that
loads './AnthropicLLMClient' and constructs new AnthropicLLMClient({ apiKey,
model: options?.model }), and on any thrown error return null (and optionally
log the error using the same logger/pattern used by other cases) so loading
failures behave consistently with the other providers.

In `@src/infrastructure/llm/OllamaLLMClient.ts`:
- Around line 91-106: The catch block in OllamaLLMClient currently wraps all
errors into a generic LLMError; modify it to detect request timeouts by checking
for an AbortError (e.g. error.name === 'AbortError' or error instanceof
DOMException) coming from AbortController.abort(), and throw a specific LLMError
like "Ollama API request timed out" (include timeout duration if available)
instead of the generic message; keep existing ECONNREFUSED handling and ensure
the new timeout branch still preserves the original error as the cause when
constructing the LLMError.

In `@src/infrastructure/llm/OpenAILLMClient.ts`:
- Around line 42-47: The local variable OpenAI is typed as `any`; change this to
a minimal structural type and use `unknown` when loading the optional SDK:
declare a minimal module shape (e.g. a type alias for the OpenAI
constructor/namespace you need) and type the variable as that shape | undefined,
then cast the result of require('openai') from unknown to that type (use
mod.default ?? mod as the typed module) instead of using `any`. Update the
symbols OpenAI and the require('openai') loading block in OpenAILLMClient.ts to
use the new minimal type and unknown cast.

In `@src/infrastructure/llm/GeminiLLMClient.ts`:
- Around line 67-92: Move the GoogleGenerativeAI instantiation and the
getGenerativeModel call into the existing try block so any errors during SDK
construction or model creation are caught and rethrown as LLMError; specifically
wrap creation of new GoogleGenerativeAI(this.apiKey) and
genAI.getGenerativeModel({ model: this.model, systemInstruction: systemPrompt })
inside the try before calling model.generateContent, and keep the existing catch
that converts non-LLMError exceptions into new LLMError(`Gemini API call failed:
${message}`) so callAPI()/complete() always receive an LLMError.

In `@src/infrastructure/llm/OpenAILLMClient.ts`:
- Around line 42-65: The OpenAI SDK resolution and try/catch should be moved out
of per-call execution and cached on the OpenAILLMClient instance: add a private
field (e.g., this.OpenAI?: OpenAIConstructor) and initialize it either in the
OpenAILLMClient constructor or via a lazy initializer used by callAPI; have the
initializer perform the require('openai') logic and throw LLMError if missing,
and then have callAPI use the cached this.OpenAI to construct the client,
avoiding repeated try/catch and repeated resolution on every call.